import com.vhly.util.DeviceInfo;

import javax.microedition.lcdui.Graphics;
import java.util.Vector;

final class cls_d
        implements inf_m {

    private static int ai[] = {
            0xffff00, 0x2050ef, 171, 0xff47e5, 0xe64600, 0x1100b5, 0xc59a00, 0xb60000, 0x474747, 0x633f19,
            8873
    };
    private static int aj[] = {
            65280, 8873, 63487, 0xc700c6, 0xffdc02, 0xb000fd, 0x558700, 0x520000, 0x212121, 0x481800,
            42425
    };
    private MainThread mainThread;
    private cls_ab al;
    cls_d a;
    cls_d b;
    cls_d c;
    int d;
    int e;
    int f;
    int g;
    cls_k h;
    cls_u i;
    private cls_u am;
    int j;
    int k;
    private int an;
    int l;
    int fld_m_int;
    int n;
    cls_aa o;
    cls_aa p;
    cls_aa q[];
    int r;
    int s;
    int t;
    private boolean ao;
    boolean u;
    boolean v;
    boolean w;
    boolean x;
    boolean y;
    int z;
    int A;
    private int ap;
    int B;
    int C;
    int D;
    int E;
    int F;
    int G;
    int H;
    int I;
    Vector J;
    int K;
    cls_l L[];
    private int aq;
    long M[];
    private long ar;
    private long as;
    boolean N;
    int O;
    private int at;
    int P;
    long Q;
    long R;
    long S;
    cls_u T;
    private cls_u au;
    private cls_k av;
    private Vector aw;
    int U[];
    private int ax;

    static boolean a(int i1) {
        return i1 >= 160 && i1 < 224;
    }

    static boolean b(int i1) {
        return i1 >= 32 && i1 < 96;
    }

    static boolean c(int i1) {
        return i1 >= 224 || i1 < 32;
    }

    static boolean d(int i1) {
        return i1 >= 96 && i1 < 160;
    }

    cls_d(MainThread thread, int i1, int j1, int k1) {
        M = new long[12];
        mainThread = thread;
        al = thread.L;
        j = 0;
        o = new cls_aa(j1, k1);
        p = new cls_aa(0, 0);
        r = i1;
        v = true;
        thread.n(i1);
        U = thread.cC[i1];
        s = inf_m.Y[i1];
        e = U[0];
        if (i1 == 50)
            return;
        k = 3;
        an = -1;
        J = new Vector();
        z = U[2];
        A = U[1];
        B = U[3];
        E = inf_m.Z[i1];
        F = G = Math.min(B, 90);
        C = U[4];
        H = inf_m.aa[s];
        q = new cls_aa[3];
        for (int l1 = 0; l1 < q.length; l1++)
            q[l1] = new cls_aa(j1, k1);

        switch (i1) {
            case 28:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            default:
                break;

            case 0:
            case 36: // '$'
            case 37: // '%'
                for (int i2 = 0; i2 < 3; i2++) {
                    cls_l lj1 = new cls_l();
                    (lj1).d = 16384;
                    lj1.a = inf_m.X[i2][0];
                    lj1.b = inf_m.X[i2][1];
                    lj1.c = inf_m.X[i2][2];
                    if (i2 != 0)
                        lj1.j = (cls_l) J.firstElement();
                    J.addElement(lj1);
                }

                L = new cls_l[3];
                L[0] = (cls_l) J.elementAt(1);
                L[1] = (cls_l) J.elementAt(0);
                L[2] = (cls_l) J.elementAt(2);
                K = 0;
                g = 4;
                f = 4;
                break;

            case 1:
                f = -1;
                break;

            case 2:
                i = new cls_u(thread.at[0]);
                b(0, 0, 5, 1);
                break;

            case 3:
                i = new cls_u(thread.at[1]);
                b(0, 0, 3, 1);
                break;

            case 4:
                i = new cls_u(thread.at[2]);
                b(0, 0, 1, 1);
                break;

            case 21: // '\025'
                i = new cls_u(thread.au[0]);
                b(18, 0, 4, 2);
                break;

            case 22: // '\026'
                i = new cls_u(thread.au[1]);
                b(15, 0, 3, 2);
                break;

            case 23: // '\027'
                i = new cls_u(thread.au[2]);
                b(12, 0, 2, 2);
                break;

            case 5:
                i = new cls_u(thread.be);
                i.l = 150;
                c(E >> 1, 72, 1, 4);
                b(0, 0, 1, 4);
                break;

            case 6:
                i = new cls_u(thread.bg);
                c(0, 24, 0, 3);
                break;

            case 7:
                i = new cls_u(thread.ax[0]);
                i.j = 3;
                b(E >> 1, 0, 4, 3);
                break;

            case 8:
                i = new cls_u(thread.ax[1]);
                i.j = 3;
                b(E >> 1, 0, 3, 3);
                break;

            case 9:
                i = new cls_u(thread.ax[2]);
                i.j = 3;
                b(E >> 1, 0, 2, 3);
                break;

            case 10:
                i = new cls_u(thread.av[0]);
                am = new cls_u(thread.aw[0]);
                T = new cls_u(thread.az[0]);
                au = new cls_u(thread.aA[0]);
                c(E, 24, 4, 3);
                break;

            case 11: // '\013'
                i = new cls_u(thread.av[1]);
                am = new cls_u(thread.aw[1]);
                T = new cls_u(thread.az[1]);
                au = new cls_u(thread.aA[1]);
                c(E, 24, 2, 3);
                break;

            case 12: // '\f'
                i = new cls_u(thread.av[2]);
                am = new cls_u(thread.aw[2]);
                T = new cls_u(thread.az[2]);
                au = new cls_u(thread.aA[2]);
                c(E, 24, 1, 3);
                break;

            case 13:
                h = new cls_k(thread.img92, 4);
                break;

            case 14: // '\016'
                h = new cls_k(thread.img91, 4);
                break;

            case 15:
                h = new cls_k(thread.img90, 4);
                break;

            case 16:
                i = new cls_u(thread.ay[0]);
                j1 = i.f >> 1;
                c(j1, 24, 5, 1);
                break;

            case 17: // '\021'
                i = new cls_u(thread.ay[1]);
                j1 = i.f >> 1;
                c(j1, 24, 4, 1);
                break;

            case 18: // '\022'
                i = new cls_u(thread.ay[2]);
                j1 = i.f >> 1;
                c(j1, 24, 1, 1);
                break;

            case 29:
                T = thread.bM[0];
                h = new cls_k(thread.aK[0], 1);
                P = T.f >> 1;
                b(0, 0, 6, 0);
                break;

            case 30: // '\036'
                T = thread.bM[1];
                h = new cls_k(thread.aK[1], 1);
                P = T.f >> 1;
                b(0, 0, 5, 0);
                break;

            case 31:
                T = thread.bM[2];
                h = new cls_k(thread.aK[2], 1);
                P = T.f >> 1;
                b(0, 0, 2, 0);
                break;

            case 19: // '\023'
                h = new cls_k(thread.img12, 16);
                break;

            case 27:
                i = new cls_u(thread.bf);
                i.c = 0;
                i.l = 150;
                b(6, 0, 4, 5);
                q = new cls_aa[18];
                for (int j2 = 0; j2 < q.length; j2++)
                    q[j2] = new cls_aa(j1, k1);

                O = q.length - 1;
                cls_d d1;
                (d1 = new cls_d(thread, 28, 0, 0)).b = this;
                d1.F = F;
                d1.G = G;
                a = d1;
                thread.fld_m_Vector.addElement(d1);
                break;

            case 32:
                h = new cls_k(thread.iceImages[0], 1);
                break;

            case 33: // '!'
                h = new cls_k(thread.iceImages[1], 1);
                break;

            case 34:
                h = new cls_k(thread.iceImages[2], 1);
                break;

            case 35:
                i = new cls_u(thread.bh);
                c(E + (E >> 1), 16, 5, 1);
                break;

            case 20: // '\024'
                c(E, 19, 7, 1);
                b(E, 0, 7, 1);
                break;

            case 24: // '\030'
                h = new cls_k(thread.img94, 5);
                break;

            case 25: // '\031'
                h = new cls_k(thread.img93, 5);
                break;

            case 26: // '\032'
                h = new cls_k(thread.img95, 5);
                break;

            case 42:
                i = thread.bB;
                av = ((cls_n) thread.K).fld_b_k;
                break;

            case 38: // '&'
                f = 7;
                c(E, 25, 1, 0);
                b(E, 0, 1, 0);
                break;

            case 39: // '\''
                f = 9;
                c(E, 25, 1, 0);
                break;

            case 40: // '('
                f = 0;
                c(E, 25, 1, 0);
                break;

            case 41: // ')'
                f = 10;
                c(E, 25, 1, 0);
                break;
        }
        aw = new Vector();
        if (f == -1) {
            f = thread.j(11);
            if (i1 == 1) {
                if (f != 2)
                    c(E, 25, 1, 0);
                if (f == 2 || f == 7)
                    b(E, 0, 1, 0);
            }
        }
        if (s == 7) {
            boolean flag = false;
            for (j1 = 0; j1 < 3; j1++) {
                if (!flag) {
                    if ((i1 = thread.j(100)) <= 10)
                        i1 = 24;
                    else if (i1 <= 20)
                        i1 = 25;
                    else if (i1 <= 30)
                        i1 = 26;
                    else
                        i1 = 1;
                    if (i1 != 1 && thread.cH[i1 - 24] > 0)
                        i1 = 1;
                } else {
                    i1 = 1;
                }
                if (i1 != 1)
                    flag = true;
                cls_d di1 = new cls_d(thread, i1, 0, 0);
                (di1).l = (j1 << 8) / 3;
                di1.fld_m_int = di1.l;
                di1.d = di1.e;
                di1.H &= 0xffffefff;
                aw.addElement(di1);
            }

        }
    }

    private void b(int i1, int j1, int k1, int l1) {
        ax = k1;
        J.addElement(new cls_l(i1, 0, k1, l1));
    }

    private void c(int i1, int j1, int k1, int l1) {
        ax = k1;
        J.addElement(new cls_l(i1, j1, k1, l1));
        J.addElement(new cls_l(i1, -j1, k1, l1));
    }

    final void a(int i1, int j1, int k1, int l1) {
        cls_l l2;
        (l2 = new cls_l()).d = j1;
        l2.j = L[i1];
        if (b != null)
            l2.a = -1;
        l2.b = k1;
        l2.c = l1;
        J.addElement(l2);
    }

    final void a(cls_aa aa1) {
        Graphics g1 = mainThread.bufferGraphics;
        int i1 = MainThread.c(o.a - aa1.a);
        int j1 = MainThread.c(o.b - aa1.b);
        int k3 = (0xff & fld_m_int + 8) >> 4;
        if (M[1] > mainThread.bR)
            mainThread.bG.a(g1, i1, j1, mainThread.bG.b, 0, 3);
        switch (s) {
            case 0:
            case 18: // '\022'
                a(g1, aa1);
                break;

            case 9:
                int l3;
                if ((l3 = (0xff & l - 64) >> 3) >= 16)
                    l3 -= 16;
                h.a(g1, i1, j1, l3, 3);
                break;

            case 15:
                if ((H & 0x10) != 0) {
                    int i4 = T.i;
                    int j6 = 8;
                    int k8 = 192;
                    int l10 = 8;
                    int l12 = h.d - T.g >> 1;
                    do {
                        if (j6 >= i4)
                            j6 %= i4;
                        int k1 = l12 * MainThread.c(MainThread.g(k8) + 128);
                        int k2 = l12 * MainThread.c(MainThread.f(k8) + 128);
                        int k13;
                        if (k8 > 0 && k8 < 128)
                            k13 = 16;
                        else if (k8 == 0 || k8 == 128)
                            k13 = 2;
                        else
                            k13 = 32;
                        if (k8 > 64 && k8 < 192)
                            k13 |= 8;
                        else if (k8 == 64 || k8 == 192)
                            k13 |= 1;
                        else
                            k13 |= 4;
                        T.a(g1, i1 + k1, j1 + k2, j6, 0, k13);
                        k8 += 32;
                        j6++;
                        k8 = 0xff & k8;
                    } while (--l10 > 0);
                }
                h.a(g1, i1, j1, 0, 3);
                break;

            case 8:
                for (int j4 = q.length - 1; j4 >= -1; j4--) {
                    int k6;
                    int l8;
                    if (j4 != -1) {
                        k6 = MainThread.c(q[j4].a - aa1.a);
                        l8 = MainThread.c(q[j4].b - aa1.b);
                    } else {
                        k6 = i1;
                        l8 = j1;
                    }
                    i.a(g1, k6, l8, i.b, (fld_m_int >> 4) % 4, 3);
                }

                break;

            case 4:
                int k4 = Math.max(B, 20) - 20;
                int l6 = Math.min((k4) / (i.i + 1), i.i - 1);
                i.a(g1, i1, j1, l6, k3, 3);
                for (int i9 = 0; i9 < J.size(); i9++) {
                    cls_l l11 = (cls_l) J.elementAt(i9);
                    if (E < 10)
                        ax = 2;
                    else
                        ax = 3;
                    l11.a = 7 + l6 * 3;
                }

                break;

            case 2:
            case 3:
            case 11: // '\013'
                i.a(g1, i1, j1, i.b, k3, 3);
                break;

            case 7:
                h.a(g1, i1, j1, 3);
                if ((mainThread.ck.H & 0x200) != 0) {
                    for (int l4 = 0; l4 < aw.size(); l4++) {
                        cls_d d1 = (cls_d) aw.elementAt(l4);
                        int j9 = (l4 << 8) / 3 + P;
                        d1.o.a = o.a + (h.c >> 3) * MainThread.g(j9);
                        d1.o.b = o.b + (h.c >> 3) * MainThread.f(j9);
                        for (int i11 = 0; i11 < d1.q.length; i11++) {
                            d1.q[i11].a = d1.o.a;
                            d1.q[i11].b = d1.o.b;
                        }

                        d1.a(aa1);
                    }

                }
                break;

            case 5:
                i.a(g1, i1, j1, i.b, k3, 3);
                break;

            case 6:
                if (P == 1) {
                    T.a(g1, i1, j1, T.b, 0, 3);
                    i.a(g1, i1, j1, i.b, k3, 3);
                } else if (P == 0) {
                    au.a(g1, i1, j1, T.b, 0, 3);
                    am.a(g1, i1, j1, i.b, k3, 3);
                }
                break;

            case 17: // '\021'
                g1.setColor((mainThread.P & 1) != 0 ? 0x116ab5 : 0xe7ebee);
                for (int i7 = 0; i7 < 256; i7 += 16)
                    if (mainThread.j(2) == 0) {
                        int l1 = MainThread.c(27 * MainThread.g(i7));
                        int l2 = MainThread.c(27 * MainThread.f(i7));
                        int k9 = MainThread.c(55 * MainThread.g(i7 + 2));
                        int j11 = MainThread.c(55 * MainThread.f(i7 + 2));
                        int i13 = MainThread.c(55 * MainThread.g(i7 - 2));
                        int i14 = MainThread.c(55 * MainThread.f(i7 - 2));
                        mainThread.a(g1, i1, j1, i1 + l1, j1 + l2);
                        mainThread.a(g1, i1 + l1, j1 + l2, i1 + k9, j1 + j11);
                        mainThread.a(g1, i1 + l1, j1 + l2, i1 + i13, j1 + i14);
                    }

                i.a(g1, i1, j1, i.b, k3, 3);
                break;

            case 13:
                for (int i5 = q.length - 1; i5 >= 0; i5--) {
                    int j7 = MainThread.c(q[i5].a - aa1.a);
                    int l9 = MainThread.c(q[i5].b - aa1.b);
                    if (O > i5)
                        g1.drawImage(mainThread.img76, j7, l9, 3);
                }

                i.a(g1, i1, j1, i.b, k3, 3);
                break;

            case 16:
                h.a(g1, i1, j1, h.a, 3);
                break;

            case 10:
                int j5 = k3 << 4;
                int i2 = MainThread.c(55 * MainThread.g(j5 - 32));
                int i3 = MainThread.c(55 * MainThread.f(j5 - 32));
                mainThread.bN.a(g1, i1 + i2, j1 + i3, mainThread.bN.b, k3, 3);
                i2 = MainThread.c(55 * MainThread.g(j5 - 96));
                i3 = MainThread.c(55 * MainThread.f(j5 - 96));
                mainThread.bN.a(g1, i1 + i2, j1 + i3, mainThread.bO.b, k3, 3);
                i2 = MainThread.c(55 * MainThread.g(j5 + 32));
                i3 = MainThread.c(55 * MainThread.f(j5 + 32));
                mainThread.bO.a(g1, i1 + i2, j1 + i3, mainThread.bN.b, k3, 3);
                i2 = MainThread.c(55 * MainThread.g(j5 + 96));
                i3 = MainThread.c(55 * MainThread.f(j5 + 96));
                mainThread.bO.a(g1, i1 + i2, j1 + i3, mainThread.bO.b, k3, 3);
                g1.setColor(0x865a20);
                MainThread.b(g1, i1, j1, 55);
                g1.setColor(0xb3873a);
                MainThread.a(g1, i1, j1, 55);
                break;

            case 12: // '\f'
                int k5 = h.b - 1;
                if (b != null) {
                    for (int k7 = q.length - 1; k7 >= 0; k7 -= 2) {
                        int i10 = MainThread.c(q[k7].a - aa1.a);
                        int k11 = MainThread.c(q[k7].b - aa1.b);
                        h.a(g1, i10, k11, k5, 3);
                        if (k5 > 1)
                            k5--;
                    }

                }
                h.a(g1, i1, j1, 0, 3);
                break;

            case 23: // '\027'
                av.a(g1, i1, j1, av.a, 3);
                i.a(g1, i1, j1, i.b, 0, 3);
                break;

            case 24: // '\030'
                if (N)
                    h.a(g1, i1, j1, 3);
                else
                    T.a(g1, i1, j1, T.b, 0, 3);
                break;

            case 25: // '\031'
                if (r == 52)
                    i.a(g1, i1, j1, i.b, k3, 3);
                return;

            case 1:
            case 19: // '\023'
            case 20: // '\024'
            case 21: // '\025'
            case 22: // '\026'
            default:
                for (int l5 = (H & 0x40) == 0 ? -1 : q.length - 1; l5 >= -1; l5--) {
                    int l7;
                    int j10;
                    if (l5 != -1) {
                        l7 = MainThread.c(q[l5].a - aa1.a);
                        j10 = MainThread.c(q[l5].b - aa1.b);
                    } else {
                        l7 = i1;
                        j10 = j1;
                    }
                    int i12;
                    if ((i12 = E - l5) >= 0) {
                        g1.setColor(ai[f]);
                        MainThread.b(g1, l7, j10, i12 + 2 >> 1);
                        g1.setColor(aj[f]);
                        MainThread.a(g1, l7, j10, i12 + 2 >> 1);
                    }
                }

                break;

            case 14: // '\016'
                break;
        }
        if (s != 0 && s != 18) {
            byte byte0 = 0;
            int i8 = 0;
            byte byte1 = 0;
            switch (ax) {
                case 0:
                    byte0 = 1;
                    byte1 = -1;
                    break;

                case 1:
                    byte0 = 0;
                    byte1 = 5;
                    break;

                case 2:
                    byte0 = 1;
                    byte1 = 0;
                    break;

                case 3:
                    byte0 = 1;
                    byte1 = 1;
                    break;

                case 4:
                case 5:
                case 6:
                    byte0 = 2;
                    byte1 = 2;
                    break;

                case 7:
                    byte0 = 4;
                    byte1 = 3;
                    break;
            }
            if (byte1 >= 0)
                if (c != null) {
                    i8 = MainThread.a(o, c.o);
                } else {
                    byte0 = 0;
                    i8 = 0;
                }
            for (int j12 = 0; j12 < J.size(); j12++) {
                cls_l l13 = (cls_l) J.elementAt(j12);
                int j3 = k3 << 4;
                j3 = 0xff & j3 + l13.b;
                int j2 = l13.a * MainThread.g(j3);
                j3 = l13.a * MainThread.f(j3);
                l13.h = o.a + j2;
                l13.i = o.b + j3;
                int j14 = MainThread.c(l13.h - aa1.a);
                j2 = MainThread.c(l13.i - aa1.b);
                mainThread.bD.a(g1, j14, j2, ax, 0, 3);
                if (byte1 >= 0) {
                    j3 = byte1 * 6 + l13.e;
                    int j13 = MainThread.c(byte0 * (MainThread.g(i8) + 128));
                    int k14 = MainThread.c(byte0 * (MainThread.f(i8) + 128));
                    mainThread.bE.a(g1, j14 + j13, j2 + k14, j3, 0, 3);
                }
                if (ax <= 0 || an == -1)
                    continue;
                j3 = fld_m_int;
                if (s != 2)
                    j3 += 64;
                mainThread.cG[ax - 1].a(g1, j14, j2, an, (j3 & 0xff) >> 4, 3);
            }

        }
        if (M[3] > mainThread.bR)
            g1.drawImage(mainThread.img36, i1, j1, 3);
        if (M[5] > mainThread.bR || M[0] > mainThread.bR)
            mainThread.bF.a(g1, i1, j1, mainThread.bF.b, 0, 3);
        if (M[2] > mainThread.bR)
            mainThread.bI.a(g1, i1 + (mainThread.j(E << 1) - E), j1 + (mainThread.j(E << 1) - E), mainThread.P % mainThread.bI.i, 0, 3);
        if (r != 0 && mainThread.R == 0 && !mainThread.A && M[8] > mainThread.bR) {
            int i6 = (F * 100) / G;
            int j8 = (i6 * 34) / 100;
            int k10 = i1 - 17;
            int k12 = j1 - (B >> 2) - 10;
            g1.setColor(0);
            g1.fillRect(k10, k12, 34, 2);
            g1.setColor(0xffff00);
            g1.drawLine(k10, k12, (k10 + j8) - 1, k12);
            g1.setColor(0xced601);
            g1.drawLine(k10, k12 + 1, (k10 + j8) - 1, k12 + 1);
            g1.setColor(0xffffff);
            g1.drawLine(k10 - 1, k12, k10 - 1, (k12 + 2) - 1);
            g1.drawLine(k10 + 34, k12, k10 + 34, (k12 + 2) - 1);
            g1.drawLine(k10, k12 - 1, (k10 + 34) - 1, k12 - 1);
            g1.drawLine(k10, k12 + 2, (k10 + 34) - 1, k12 + 2);
        }
    }

    final void a(Graphics g1, cls_aa aa1) {
        byte byte0 = 0;
        int l8 = 0;
        boolean flag1 = g(32);
        int i9 = 4 + (20 * B) / 65;
        boolean flag;
        if (flag = M[11] > mainThread.bR)
            i9 += I * (mainThread.P % 4);
        int j9 = aq * MainThread.g(fld_m_int);
        int k9 = aq * MainThread.f(fld_m_int);
        o.a += j9;
        o.b += k9;
        int l9 = (H & 0x10000) == 0 || mainThread.gameState == 8 ? 0 : -1;
        if (M[10] < mainThread.bR - 1000L)
            M[10] = mainThread.bR;
        int ai1[] = mainThread.cE[f];
        int ai2[] = mainThread.cE[K != 6 ? f : g];
        int ai3[] = mainThread.cE[K != 7 && K != 0 ? f : g];
        int i10 = mainThread.cE[g][24];
        int j10 = mainThread.cE[g][g != f ? 31 : 30];
        cls_l l10 = null;
        if (flag1) {
            cls_l l11 = L[0];
            cls_l l12 = L[1];
            cls_l l13 = L[2];
            boolean flag2 = false;
            boolean flag4 = false;
            boolean flag5 = false;
            for (int k14 = 0; k14 < J.size(); k14++) {
                cls_l l1;
                if ((l1 = (cls_l) J.elementAt(k14)).d != 32)
                    continue;
                if (l1.j == l11) {
                    flag2 = true;
                    continue;
                }
                if (l1.j == l12) {
                    flag4 = true;
                    continue;
                }
                if (l1.j == l13)
                    flag5 = true;
            }

            if (flag2 && flag4)
                if (l12.c > l11.c)
                    flag2 = false;
                else
                    flag4 = false;
            if (flag2 && flag5)
                if (l13.c > l11.c)
                    flag2 = false;
                else
                    flag5 = false;
            if (flag4 && flag5)
                if (l13.c > l12.c)
                    flag4 = false;
                else
                    flag5 = false;
            if (flag2)
                l10 = l11;
            else if (flag4)
                l10 = l12;
            else if (flag5)
                l10 = l13;
        }
        cls_d d1 = null;
        if ((H & 0x200) != 0) {
            if (s == 0)
                d1 = mainThread.cm;
            else
                d1 = c;
            if (d1 != null) {
                l8 = MainThread.a(o, d1.o);
            } else {
                byte0 = 0;
                l8 = 0;
            }
        }
        for (int k10 = 0; k10 < J.size(); k10++) {
            cls_l i11 = (cls_l) J.elementAt(k10);
            boolean flag3 = false;
            if (flag1 && (i11.j != l10 || i11.d != 32 && i11.d != 16 && i11.d != 8)) {
                flag3 = true;
                if (l9 == -1) {
                    for (int j13 = 0; j13 < J.size(); j13++) {
                        cls_l l14;
                        if ((l14 = (cls_l) J.elementAt(j13)).d == 32 && l14.j == i11)
                            flag3 = false;
                    }

                }
            }
            int j1;
            int i14;
            int j14;
            if (i11.j != null) {
                int i15;
                j1 = MainThread.c(MainThread.d((i15 = MainThread.b(i11.j.c * i9)) / 100));
                if (i11.a >= 0) {
                    int k1;
                    int j15;
                    int k13 = Math.max(k1 = MainThread.c(MainThread.d((j15 = MainThread.b(i11.c * i9)) / 100)), j1);
                    int l15 = k1 + j1;
                    j1 = k13 + ((l15 - k13) * i11.a) / 100;
                }
                i14 = i11.j.f;
                j14 = i11.j.g;
            } else {
                j1 = i11.a;
                i14 = o.a;
                j14 = o.b;
            }
            int i1 = 0xff & fld_m_int + i11.b;
            int k15 = (0xff & i1 + 8) >> 4;
            int i2 = j1 * MainThread.g(i1);
            int k5 = j1 * MainThread.f(i1);
            i11.f = i14 + i2;
            i11.g = j14 + k5;
            i11.h = MainThread.c(i11.f - aa1.a);
            i11.i = MainThread.c(i11.g - aa1.b);
            if (flag3)
                continue;
            i14 = MainThread.c(i14 - aa1.a);
            j14 = MainThread.c(j14 - aa1.b);
            switch (i11.d) {
                case 16384:
                    int j2;
                    i14 = MainThread.c(MainThread.d((j2 = MainThread.b(i11.c * i9)) / 100));
                    if (l9 == 0) {
                        g1.setColor(ai3[24]);
                        MainThread.b(g1, i11.h, i11.i, i14 + 2);
                        g1.setColor(ai3[30]);
                        MainThread.b(g1, i11.h, i11.i, i14 + (K != 7 ? 1 : 0));
                    } else if (l9 == 1) {
                        if (i11.j != null) {
                            if (K == 6) {
                                g1.setColor(j10);
                                MainThread.b(g1, i11.h, i11.i, i14);
                                g1.setColor(i10);
                                MainThread.a(g1, i11.h, i11.i, i14);
                            } else {
                                byte byte1 = ((byte) (K != 7 ? 0 : -2));
                                g1.setColor(ai2[31]);
                                MainThread.b(g1, i11.h, i11.i, i14 + byte1);
                                if (K == 7) {
                                    g1.setColor(ai2[24]);
                                    MainThread.a(g1, i11.h, i11.i, i14 + byte1);
                                }
                            }
                        } else {
                            g1.setColor(ai1[31]);
                            MainThread.b(g1, i11.h, i11.i, i14);
                        }
                    } else if (l9 == 2)
                        switch (K) {
                            case 3:
                            case 4:
                                int i16 = k10 << 6;
                                int j11;
                                int l18 = ((j11 = i14 / 3) << 1) - 2;
                                for (int l20 = 0; l20 < 3 && j11 > 1; l20++) {
                                    g1.setColor(j10);
                                    int k2 = MainThread.c(l18 * MainThread.g(i1 + l20 * 85 + i16));
                                    int l5 = MainThread.c(l18 * MainThread.f(i1 + l20 * 85 + i16));
                                    MainThread.b(g1, i11.h + k2, i11.i + l5, j11);
                                    if (K == 3) {
                                        g1.setColor(i10);
                                        MainThread.a(g1, i11.h + k2, i11.i + l5, j11);
                                    } else {
                                        g1.setColor(ai1[31]);
                                        MainThread.b(g1, i11.h + k2, i11.i + l5, j11 - 1);
                                        g1.setColor(i10);
                                        MainThread.a(g1, i11.h + k2, i11.i + l5, j11 - 1);
                                    }
                                    j11--;
                                }

                                break;

                            case 2:
                                int j16 = i14 / 6;
                                int l2 = MainThread.c(i14 * MainThread.g(fld_m_int));
                                int i6 = MainThread.c(i14 * MainThread.f(fld_m_int));
                                int k11 = MainThread.c(i14 * MainThread.g(fld_m_int - 128));
                                int i19 = MainThread.c(i14 * MainThread.f(fld_m_int - 128));
                                g1.setColor(ai1[24]);
                                g1.drawLine(i11.h + l2, i11.i + i6, i11.h + k11, i11.i + i19);
                                if (j16 > 0) {
                                    int i21 = i14 - j16;
                                    for (int i22 = 0; i22 < 6; i22++) {
                                        g1.setColor(j10);
                                        int i3 = MainThread.c(i21 * MainThread.g(fld_m_int + 36 * (i22 + 1)));
                                        int j6 = MainThread.c(i21 * MainThread.f(fld_m_int + 36 * (i22 + 1)));
                                        MainThread.b(g1, i11.h + i3, i11.i + j6, j16);
                                        g1.setColor(i10);
                                        MainThread.a(g1, i11.h + i3, i11.i + j6, j16);
                                    }

                                    i21 >>= 1;
                                    g1.setColor(j10);
                                    int j3 = MainThread.c(i21 * MainThread.g(fld_m_int + 58));
                                    int k6 = MainThread.c(i21 * MainThread.f(fld_m_int + 58));
                                    MainThread.b(g1, i11.h + j3, i11.i + k6, j16);
                                    g1.setColor(i10);
                                    MainThread.a(g1, i11.h + j3, i11.i + k6, j16);
                                    g1.setColor(j10);
                                    j3 = MainThread.c(i21 * MainThread.g(fld_m_int - 58));
                                    k6 = MainThread.c(i21 * MainThread.f(fld_m_int - 58));
                                    MainThread.b(g1, i11.h + j3, i11.i + k6, j16);
                                    g1.setColor(i10);
                                    MainThread.a(g1, i11.h + j3, i11.i + k6, j16);
                                }
                                break;

                            case 1:
                                int k16 = 360 * (0xff & 256 - fld_m_int) >> 8;
                                int i12 = i14 << 1;
                                g1.setColor(j10);
                                g1.fillArc(i11.h - i14, i11.i - i14, i12, i12, k16, 180);
                                int k3 = MainThread.c(i14 * MainThread.g(fld_m_int));
                                int l6 = MainThread.c(i14 * MainThread.f(fld_m_int));
                                int j19 = MainThread.c(i14 * MainThread.g(fld_m_int - 128));
                                int j21 = MainThread.c(i14 * MainThread.f(fld_m_int - 128));
                                g1.setColor(i10);
                                g1.drawLine(i11.h + k3, i11.i + l6, i11.h + j19, i11.i + j21);
                                break;

                            case 8:
                                j1 = i14 >> 1;
                                int l16 = i14 >> 2;
                                int l3 = MainThread.c(j1 * MainThread.g(fld_m_int - 64));
                                int i7 = MainThread.c(j1 * MainThread.f(fld_m_int - 64));
                                g1.setColor(j10);
                                MainThread.b(g1, i11.h + l3, i11.i + i7, l16);
                                g1.setColor(i10);
                                MainThread.a(g1, i11.h + l3, i11.i + i7, l16);
                                l3 = MainThread.c(j1 * MainThread.g(fld_m_int + 64));
                                i7 = MainThread.c(j1 * MainThread.f(fld_m_int + 64));
                                g1.setColor(j10);
                                MainThread.b(g1, i11.h + l3, i11.i + i7, l16);
                                g1.setColor(i10);
                                MainThread.a(g1, i11.h + l3, i11.i + i7, l16);
                                break;

                            case 5:
                            case 9:
                                int i17 = i14 - 1;
                                for (int j12 = 0; i17 > 0; j12++) {
                                    if (K == 9 || (j12 & 1) == 0) {
                                        g1.setColor(j10);
                                        MainThread.b(g1, i11.h, i11.i, i17);
                                        g1.setColor(i10);
                                        MainThread.a(g1, i11.h, i11.i, i17);
                                    } else {
                                        g1.setColor(ai1[31]);
                                        MainThread.b(g1, i11.h, i11.i, i17);
                                        g1.setColor(ai1[24]);
                                        MainThread.a(g1, i11.h, i11.i, i17);
                                    }
                                    i17 -= 3;
                                }

                                if (K != 5) {
                                    for (int k19 = 0; k19 < 128; k19 += 32) {
                                        int i4 = MainThread.c(i14 * MainThread.g(k19));
                                        int j7 = MainThread.c(i14 * MainThread.f(k19));
                                        int k21 = MainThread.c(i14 * MainThread.g(k19 - 128));
                                        int j22 = MainThread.c(i14 * MainThread.f(k19 - 128));
                                        g1.setColor(ai1[31]);
                                        g1.drawLine(i11.h + i4, i11.i + j7 + 1, i11.h + k21, i11.i + j22 + 1);
                                        g1.setColor(ai1[24]);
                                        g1.drawLine(i11.h + i4, i11.i + j7, i11.h + k21, i11.i + j22);
                                    }

                                }
                                break;
                        }
                    else if (l9 == -1) {
                        int j17;
                        if ((j17 = (int) ((512L * (mainThread.bR - M[10])) / 1000L) % 512) > 256)
                            j17 = 256 - j17 % 256;
                        g1.setColor(((byte) (255 - j17) << 16) + ((byte) (255 - j17) << 8) + 255);
                        MainThread.b(g1, i11.h, i11.i, i14 + 5);
                    }
                    break;

                case 32:
                    cls_u u1;
                    cls_u u3;
                    byte byte2;
                    byte byte3;
                    int k22;
                    if ((k22 = MainThread.c((MainThread.b(i11.j.c) * i9) / 100)) >= 9) {
                        byte2 = 10;
                        byte3 = 16;
                        u3 = mainThread.bs[f];
                        u1 = mainThread.bu[f];
                    } else {
                        byte2 = 4;
                        byte3 = 8;
                        u3 = mainThread.br[f];
                        u1 = mainThread.bt[f];
                    }
                    j1 = u1.f >> 1;
                    j1 = (k22 + 2) - j1;
                    if (k22 >= byte2)
                        for (int ii11 = 0; ii11 < byte3; ii11++) {
                            int j4 = ii11 << 1;
                            if (ii11 >= byte3 >> 1)
                                j4 -= byte3 + 1;
                            int l19 = i1 + (j4 << 8) / byte3;
                            j4 = MainThread.c(j1 * MainThread.g(l19));
                            int k7 = MainThread.c(j1 * MainThread.f(l19));
                            u1.a(g1, i14 + j4, j14 + k7, u1.b, (0xff & l19 + 8) >> 4, 3);
                        }

                    u3.a(g1, i14, j14, u3.b, k15, 3);
                    break;

                case 2:
                    int k17;
                    if (M[7] > mainThread.bR)
                        k17 = mainThread.bm[f].b;
                    else
                        k17 = mainThread.bm[f].e;
                    mainThread.bm[f].a(g1, i11.h, i11.i, k17, k15, 3);
                    break;

                case 64:
                    mainThread.bv[f].a(g1, i11.h, i11.i, mainThread.bv[f].b, k15, 3);
                    break;

                case 512:
                    int k12;
                    int l17;
                    if ((k12 = MainThread.c(((l17 = (MainThread.b(i11.j.c) * i9) / 100) << 3) / 24)) >= 7)
                        k12 = 6;
                    if (d1 != null)
                        switch (k12) {
                            case 0:
                            case 1:
                                byte0 = 0;
                                break;

                            case 2:
                            case 3:
                                byte0 = 1;
                                break;

                            case 4:
                            case 5:
                            case 6:
                                byte0 = 2;
                                break;
                        }
                    else
                        byte0 = 0;
                    mainThread.bD.a(g1, i11.h, i11.i, k12, 0, 3);
                    int i20 = MainThread.c(byte0 * (MainThread.g(l8) + 128));
                    int l21 = MainThread.c(byte0 * (MainThread.f(l8) + 128));
                    mainThread.bE.a(g1, i11.h + i20, i11.i + l21, 0, 0, 3);
                    if (k12 > 0 && an != -1) {
                        int l22 = fld_m_int + 64;
                        mainThread.cG[k12 - 1].a(g1, i11.h, i11.i, an, (l22 & 0xff) >> 4, 3);
                    }
                    break;

                case 1:
                    int i18;
                    if (M[6] > mainThread.bR)
                        i18 = mainThread.bl[f].b;
                    else
                        i18 = 0;
                    mainThread.bl[f].a(g1, i11.h, i11.i, i18, k15, 3);
                    break;

                case 256:
                    mainThread.by[f].a(g1, i11.h, i11.i, mainThread.by[f].b, k15, 3);
                    if (s == 0 && mainThread.bU > mainThread.bR && d > e >> 1 || s == 18 && N && d > e >> 1) {
                        int k4 = MainThread.c(10 * MainThread.g(i1));
                        int l7 = MainThread.c(10 * MainThread.f(i1));
                        mainThread.bH.a(g1, i11.h + k4, i11.i + l7, mainThread.bH.b, k15, 3);
                    }
                    break;

                case 1024:
                    int j18 = i1;
                    cls_aa aa2;
                    int j20;
                    if (mainThread.cm != null && Math.abs(j20 = (j18 = MainThread.a(aa2 = new cls_aa(MainThread.c(i11.f), MainThread.c(i11.g)), mainThread.cm.o)) - i1) > 32)
                        j18 = 0xff & i1;
                    mainThread.bz[f].a(g1, i11.h, i11.i, mainThread.bz[f].b, j18 >> 4, 3);
                    break;

                case 2048:
                    mainThread.bA[f].a(g1, i11.h, i11.i, mainThread.bA[f].b, k15, 3);
                    break;

                case 4:
                    if (Q < mainThread.bR)
                        mainThread.bn[f].a(g1, i11.h, i11.i, mainThread.bn[f].b, k15, 3);
                    else
                        mainThread.bn[f].a(g1, i11.h, i11.i, mainThread.bn[f].d, k15, 3);
                    break;

                case 16:
                    int k18 = mainThread.bq[f].i - 1;
                    if (M[9] < mainThread.bR && !flag1)
                        k18 = 0;
                    int l4 = MainThread.c(j1 * MainThread.g(i1));
                    int i8 = MainThread.c(j1 * MainThread.f(i1));
                    mainThread.bq[f].a(g1, i14 + l4, j14 + i8, k18, (0xff & i1 + 8) >> 4, 3);
                    int i13 = fld_m_int - i1;
                    i1 = 0xff & fld_m_int + i13;
                    l4 = MainThread.c(j1 * MainThread.g(i1));
                    i8 = MainThread.c(j1 * MainThread.f(i1));
                    mainThread.bq[f].a(g1, i14 + l4, j14 + i8, k18, (0xff & i1 + 8) >> 4, 3);
                    break;

                case 8:
                case 128:
                    cls_u u2;
                    cls_u u4;
                    if (i11.d == 128) {
                        u4 = mainThread.bw[f];
                        u2 = mainThread.bx[f];
                    } else {
                        u4 = mainThread.bo[f];
                        u2 = mainThread.bp[f];
                    }
                    u4.a(g1, i11.h, i11.i, u4.b, (0xff & i1 + 8) >> 4, 3);
                    int k20 = fld_m_int - i1;
                    i1 = 0xff & fld_m_int + k20;
                    int i5 = i11.j.f + j1 * MainThread.g(i1);
                    int j8 = i11.j.g + j1 * MainThread.f(i1);
                    i5 = MainThread.c(i5 - aa1.a);
                    j8 = MainThread.c(j8 - aa1.b);
                    u2.a(g1, i5, j8, u2.b, (0xff & i1 + 8) >> 4, 3);
                    break;

                case 32768:
                    if (mainThread.bV < mainThread.bR) {
                        J.removeElementAt(k10--);
                        continue;
                    }
                    if (mainThread.bV - mainThread.bR < 1000L && (mainThread.P & 1) == 0)
                        continue;
                    if (mainThread.cc == k15 % 4) {
                        int j5 = MainThread.c(j1 * MainThread.g(i1));
                        int k8 = MainThread.c(j1 * MainThread.f(i1));
                        mainThread.bC.a(g1, i14 + j5, j14 + k8, 0, k15, 3);
                    }
                    break;
            }
            if (k10 == 2 && l9 < 2) {
                l9++;
                k10 = -1;
            }
        }

        o.a -= j9;
        o.b -= k9;
    }

    final void a() {
        int i1 = 4 + (20 * B) / 65;
        cls_l l2 = L[0];
        cls_l l1 = L[1];
        cls_l l3 = L[2];
        boolean flag = false;
        int k1 = 0;
        boolean bk1 = false;
        boolean flag1 = false;
        boolean flag2;
        if (flag2 = g(32)) {
            for (int i2 = 0; i2 < J.size(); i2++) {
                cls_l l4;
                if ((l4 = (cls_l) J.elementAt(i2)).d != 32)
                    continue;
                if (l4.j == l2) {
                    flag = true;
                    continue;
                }
                if (l4.j == l1) {
                    k1 = 1;
                    continue;
                }
                if (l4.j == l3)
                    flag1 = true;
            }

            if (flag && bk1)
                if (l1.c > l2.c)
                    flag = false;
                else
                    bk1 = false;
            if (flag && flag1)
                if (l3.c > l2.c)
                    flag = false;
                else
                    flag1 = false;
            if (bk1 && flag1 && l3.c <= l1.c)
                flag1 = false;
        }
        int i3;
        int j2 = ((((l2.c) << 8) * i1) / 100) >> 8;
        int k2 = ((((l1.c) << 8) * i1) / 100) >> 8;
        k1 = ((((l3.c) << 8) * i1) / 100) >> 8;
        i1 = Math.max(j2, k2);
        int j1 = j2 + k2;
        i3 = i1 + ((j1 - i1) * l2.a) / 100;
        i1 = Math.max(k1, k2);
        j1 = k1 + k2;
        i1 += ((j1 - i1) * l3.a) / 100;
        j1 = (i3 + j2) * MainThread.g(l2.b);
        i1 = (i1 + k1) * MainThread.g(l3.b);
        if (!flag2) {
            int j3;
            aq = -((j1 + i1 >> 1) >> 8);
            i1 = (i1 = (j1 - i1) >> 8) * i1;
            E = (MainThread.e(i1) >> 1) >> 8;
            return;
        }
        if (flag) {
            int k3;
            aq = -((j1) >> 8) + j2;
            E = j2;
            return;
        }
        if (flag1) {
//            int i4;
            aq = -((i1) >> 8) - k1;
            E = k1;
//            return;
        } else {
//            int j4;
            aq = -((j1 + i1 >> 1) >> 8);
            E = k2;
//            return;
        }
    }

    final void e(int i1) {
        if (M[3] > mainThread.bR)
            d = 2;
        if (s != 14) {
            int j1 = i1;
            int l1;
            if ((l1 = 0xff & l - fld_m_int) != 0)
                if (l1 < 128)
                    this.l--;
                else
                    this.l++;
            this.l = 0xff & l;
            int j2 = MainThread.g(l);
            p.a = j2 * (l1 = d * j1) >> 8;
            j2 = MainThread.f(l);
            p.b = j2 * (l1 = d * j1) >> 8;
            if ((H & 0x40) != 0) {
                for (int k1 = q.length - 1; k1 > 0; k1--) {
                    q[k1].a = q[k1 - 1].a;
                    q[k1].b = q[k1 - 1].b;
                }

                q[0].a = o.a;
                q[0].b = o.b;
            }
            o.a += p.a;
            o.b += p.b;
            j2 = 238;
            this.d = j2 * (l1 = d) >> 8;
            if (d < 2)
                this.d = 2;
        } else {
            o = b.q[b.O];
        }
        if ((H & 0x200) != 0) {
            if (k == 3 && mainThread.j(75) == 0)
                k = 1;
            switch (k) {
                case 3:
                default:
                    break;

                case 0:
                    if (an >= 0)
                        an--;
                    if (an == -1)
                        k = 3;
                    break;

                case 1:
                    if (an < 2)
                        an++;
                    if (an == 2)
                        k = 4;
                    break;

                case 2:
                    an = 1;
                    break;

                case 4:
                    k = 0;
                    break;

                case 5:
                    an = 2;
                    break;
            }
        }
        if (s != 0)
            e();
        if (s == 0 || s == 18) {
            if (M[3] < mainThread.bR) {
                if (mainThread.bl[f] != null)
                    mainThread.bl[f].a(mainThread.bR);
                if (mainThread.bm[f] != null)
                    mainThread.bm[f].a(mainThread.bR);
                if (mainThread.bn[f] != null)
                    mainThread.bn[f].a(mainThread.bR);
                if (mainThread.bv[f] != null)
                    mainThread.bv[f].a(mainThread.bR);
                if (mainThread.bw[f] != null)
                    mainThread.bw[f].a(mainThread.bR);
                if (mainThread.bx[f] != null)
                    mainThread.bx[f].a(mainThread.bR);
                if (mainThread.by[f] != null)
                    mainThread.by[f].a(mainThread.bR);
                if (mainThread.bH != null)
                    mainThread.bH.a(mainThread.bR);
                if (mainThread.bz[f] != null)
                    mainThread.bz[f].a(mainThread.bR);
                if (mainThread.bA[f] != null)
                    mainThread.bA[f].a(mainThread.bR);
                if ((H & 4) != 0 && Q > mainThread.bR) {
                    mainThread.bG.a();
                    if (mainThread.bG.b == 4)
                        mainThread.bG.a(mainThread.bG.b, mainThread.bG.e);
                } else if (g(2048) && mainThread.bR - (Q - 10000L) > 3000L)
                    N = false;
                if (N) {
                    if ((H & 0x20) != 0 && mainThread.bR - (Q - 10000L) > 3000L) {
                        N = false;
                        C = U[4];
                        a();
                    }
                    if (s == 18 && (H & 0x100) != 0 && mainThread.bR - (Q - 10000L) > 6000L) {
                        N = false;
                        char c1 = '\u014C';
                        int i2;
                        e = c1 * (i2 = U[0]) >> 8;
                        d = Math.min(d, e);
                    }
                }
            } else {
                mainThread.bT = 0L;
            }
            ap = 0;
            if ((H & 2) != 0)
                ap += 5;
            ap += B;
            if (mainThread.B)
                ap += 1000;
        } else if (mainThread.R == 1 && j == 1)
            d = 0;
        if (M[2] > mainThread.bR) {
            if (ar <= 0L)
                ar = mainThread.bR + 1000L;
            if (mainThread.bR > ar) {
                ar = mainThread.bR + 1000L;
                R = 0L;
                f(s != 0 && s != 18 ? 5 : 2);
            }
            if (r != 0)
                d = 2;
        } else {
            ar = -1L;
        }
        if (M[4] > mainThread.bR) {
            if (as <= 0L)
                as = mainThread.bR + 500L;
            if (mainThread.bR > as) {
                if (M[2] > mainThread.bR && M[2] != 0L)
                    M[2] = -1L;
                if (s == 0) {
                    B = Math.min(65, B + 2);
                    M[11] = 1500L + mainThread.bR;
                    I = 1;
                } else if (s == 18)
                    F = Math.min(G, F + 4);
                as = mainThread.bR + 500L;
                return;
            }
        } else {
            as = -1L;
        }
    }

    final void b() {
        if ((s == 0 || s == 18) && (g(32) || y))
            return;
        if (d < e) {
            char c1 = '\u0200';
            int i1;
            d = c1 * (i1 = d) >> 8;
        }
        if (s == 0 && d > e)
            d = e;
        int j1;
        if (Math.abs(j1 = l - fld_m_int) <= A)
            l = fld_m_int;
        else if ((0xff & j1) < 128)
            l -= A;
        else
            l += A;
        l = 0xff & l;
    }

    final void c() {
        char c1 = '\372';
        int i1;
        d = c1 * (i1 = d) >> 8;
        if (d < 2)
            d = 2;
    }

    private void e() {
        ap = 0;
        if (s != 7)
            ap += B;
        if (!s()) {
            if (mainThread.R != 1) {
                cls_d d1;
                switch (s) {
                    case 1:
                        if ((d1 = this).c != null && d1.t > 118 && !d1.c.g(2048) && d1.c.s != 17)
                            d1.c = null;
                        if (d1.c != null) {
                            int j1 = MainThread.a(d1.o, d1.c.o);
                            int i2 = d1.A;
                            switch (d1.c.s) {
                                case 1:
                                    if (d1.f == d1.c.f)
                                        j1 = 0xff & j1 + 128;
                                    break;

                                case 14: // '\016'
                                    break;

                                case 17: // '\021'
                                    int i3 = 0xff & d1.fld_m_int - j1;
                                    i2 <<= 1;
                                    if (i3 >= 32 && i3 <= 224)
                                        break;
                                    if (d1.d <= d1.c.d)
                                        d1.d = d1.d + d1.c.d >> 1;
                                    d1.l = d1.fld_m_int;
                                    break;

                                default:
                                    if (d1.c.g(2048)) {
                                        d1.fld_m_int = d1.l = j1;
                                        d1.d = d1.e << 2;
                                    } else {
                                        j1 = 0xff & j1 + 128;
                                    }
                                    break;
                            }
                            int j3 = d1.fld_m_int - j1;
                            d1.ao = true;
                            if (Math.abs(j3) <= i2)
                                d1.fld_m_int = j1;
                            else if ((0xff & j3) < 128)
                                d1.fld_m_int -= i2;
                            else
                                d1.fld_m_int += i2;
                            d1.fld_m_int = 0xff & d1.fld_m_int;
                        }
                        break;
                    case 2:
                        f();
                        break;
                    case 3:
                        g();
                        break;
                    case 4:
                        cls_d d2;
                        if ((d2 = this).c != null) {
                            if (d2.t <= 130) {
                                int k1;
                                int j2;
                                d2.ao = true;
                                k1 = MainThread.a(d2.o, d2.c.o);
                                j2 = d2.fld_m_int - k1;
                                if ((0xff & j2) < 32 || (0xff & j2) > 224) {
                                    d2.u = false;
                                    if (d2.c.B > d2.U[3] && !d2.N) {
                                        d2.N = true;
                                        d2.e = d2.U[0] * 3;
                                    } else if (d2.B > d2.c.B && d2.N && d2.ap > d2.c.ap) {
                                        if (Math.abs(j2) <= d2.A)
                                            d2.fld_m_int = k1;
                                        else if ((0xff & j2) < 128)
                                            d2.fld_m_int -= d2.A;
                                        else
                                            d2.fld_m_int += d2.A;
                                        d2.fld_m_int = 0xff & d2.fld_m_int;
                                    } else if (d2.c.B > d2.B && d2.N || d2.c.ap > d2.ap) {
                                        k1 = 0xff & k1 + 128;
                                        int k2;
                                        if (Math.abs(k2 = d2.fld_m_int - k1) <= d2.A)
                                            d2.fld_m_int = k1;
                                        else if ((0xff & k2) < 128)
                                            d2.fld_m_int -= d2.A;
                                        else
                                            d2.fld_m_int += d2.A;
                                        d2.fld_m_int = 0xff & d2.fld_m_int;
                                    }
                                }
                            } else {
                                d2.c = null;
                            }
                            if ((d2.c == null || d2.c.B < d2.U[3]) && d2.B == 65) {
                                d2.N = false;
                                d2.e = d2.U[0];
                            }
                        }
                        if (!d2.N && !d2.u && d2.Q < d2.mainThread.bR) {
                            d2.n = 0xff & d2.fld_m_int + d2.mainThread.j(64);
                            d2.u = true;
                            d2.Q = d2.mainThread.bR + 1000L;
                        }
                        if (d2.N && d2.B < 65) {
                            d2.B = Math.min(65, d2.B + 2);
                            d2.E = d2.B >> 2;
                        } else if (!d2.N && d2.B > d2.U[3]) {
                            d2.B -= 2;
                            d2.E = d2.B >> 2;
                        }
                        break;
                    case 5:
                        ap = 100;
                        this.o();
                        break;
                    case 6:
                        if (P == 1)
                            this.ap += 10;
                        else if (this.P == 0)
                            this.ap -= 20;
                        this.o();
                        break;
                    case 7:
                        i();
                        break;
                    case 8:
                        l();
                        break;
                    case 9:
                        if (c != null && this.t > 110)
                            this.c = null;
                        if (c == null)
                            x = true;
                        ao = true;
                        break;
                    case 11:
                        h();
                        break;
                    case 12:
                        k();
                        break;
                    case 13:
                        m();
                        break;
                    case 15:
                        if (Q < this.mainThread.bR) {
                            if ((H & 0x10) != 0)
                                H &= 0xffffffef;
                            else
                                H |= 0x10;
                            Q = mainThread.bR + 2000L;
                        }
                        o();

                        break;
                    case 16:
                        ap += 1000;
                        ao = true;
                        break;
                    case 17:
                        j();
                        break;
                    case 18:
                        n();
                        break;
                    case 25:
                        if (r == 52)
                            o();
                        break;
                    case 10:
                    case 14:
                    case 19:
                    case 20:
                    case 21:
                    case 22:
                    case 23:
                    case 24:
                    default:
                        o();
                        break;
                }
            }

            cls_d d9;
            switch (s) {
                case 21: // '\025'
                default:
                    o();
                    break;

                case 23: // '\027'
                    cls_d d8;
                    (d8 = this).av.a();
                    d8.i.a();
                    break;

                case 19: // '\023'
                    (d9 = this).ao = true;
                    break;

                case 20: // '\024'
                    p();
                    break;

                case 22: // '\026'
                    q();
                    break;

                case 24: // '\030'
                    r();
                    break;
            }
//        break; /* Loop/switch isn't completed */
        } else {
            _L2:
            ap -= 10;
            c = null;
            N = false;
            Q = 0L;
            P = 0;
            if (j != 1)
                j = 0;
            if (s == 5 || s == 6) {
                if (mainThread.bR - i.m > 150L) {
                    i.a();
                    i.m = mainThread.bR;
                }
                long l1;
                long l2;
                byte byte0;
                if (s == 6) {
                    if (mainThread.bR - T.m > 100L) {
                        T.a();
                        au.a();
                        T.m = mainThread.bR;
                    }
                    l1 = inf_m.V[P];
                    l2 = 1000L;
                    byte0 = 2;
                } else {
                    l1 = 0L;
                    l2 = 3000L;
                    byte0 = 3;
                }
                if (mainThread.bR - Q > l1) {
                    O = (int) ((256L * (mainThread.bR - Q)) / l2) % 256;
                    if (O < at) {
                        N = true;
                        P = ++P % byte0;
                        Q = mainThread.bR;
                        O = 0;
                        at = 0;
                    } else {
                        N = false;
                        at = O;
                    }
                }
            }
            if (ao) {
                b();
                ao = false;
            }
            int i1;
            if (u) {
                if (Math.abs(i1 = fld_m_int - n) <= A) {
                    fld_m_int = n;
                    u = false;
                } else if ((0xff & i1) < 128)
                    fld_m_int -= A;
                else
                    fld_m_int += A;
            } else if (fld_m_int != l)
                if (Math.abs(i1 = l - fld_m_int) <= A)
                    l = fld_m_int;
                else if ((0xff & i1) < 128)
                    l -= A;
                else
                    l += A;
            fld_m_int = 0xff & fld_m_int;
        }
        return;
    }

    private void f() {
        if (c != null && ao && !u && mainThread.j(100) == 0 && d <= e) {
            d = e << 1;
            ap += 5;
        } else if (d > e)
            d = e;
        if (c != null && B > c.B) {
            if (t < 35) {
                i.j = 3;
                i.a(0, i.i - 1);
            } else {
                i.j = 0;
                i.a(2, 2);
            }
        } else {
            i.j = 0;
            i.a(2, 2);
        }
        if (mainThread.bR - i.m > 150L) {
            i.a();
            i.m = mainThread.bR;
        }
        o();
    }

    private void g() {
        if (c != null && t > 118)
            c = null;
        if (d > 2)
            i.a(0, i.i - 1);
        else
            i.a(0, 0);
        i.a(mainThread.bR);
        if (Q < mainThread.bR && (ao || N))
            if (P++ == 4) {
                Q = mainThread.bR + 3000L;
                P = 0;
                N = false;
            } else {
                int j1;
                int i1 = ((j1 = o.a) >> 8) + (mainThread.j(20) - 10);
                j1 = ((j1 = o.b) >> 8) + (mainThread.j(20) - 10);
                T = new cls_u(mainThread.bc);
                T.n = new cls_aa(i1, j1);
                T.l = 150;
                T.m = mainThread.bR;
                mainThread.K.vector.addElement(T);
                Q = mainThread.bR + 500L;
                N = true;
            }
        c();
    }

    private void h() {
        if (c != null && c.s != 0)
            if (B > c.B && ap > c.ap) {
                if (t > 120)
                    c = null;
            } else if (t > 80)
                c = null;
        if (c != null) {
            int j1 = MainThread.a(o, c.o);
            int i1;
            if (B > c.B && ap > c.ap) {
                i1 = fld_m_int - j1 & 0xff;
                if (j == 4 && (i1 < 16 || i1 > 240)) {
                    j = 5;
                    Q = mainThread.bR + 1500L;
                } else if (j == 5 && Q < mainThread.bR) {
                    j = 6;
                    Q = mainThread.bR + 1000L;
                } else if (j == 6 && Q < mainThread.bR && v) {
                    int l1;
                    int k1 = (l1 = o.a - mainThread.ci.a) >> 8;
                    l1 = (l1 = o.b - mainThread.ci.b) >> 8;
                    if (k1 >= 0 && k1 < DeviceInfo.DEVICE_SCREEN_WIDTH && l1 >= 0 && l1 < DeviceInfo.DEVICE_SCREEN_HEIGHT) {
                        j = 2;
                        Q = mainThread.bR + 2000L;
                        d = e << 1;
                        byte byte0 = 13;
                        cls_ab ab1 = al;
                        al.a(byte0, false);
                    }
                }
            } else {
                j = 0;
                j1 = 0xff & j1 + 128;
                i1 = fld_m_int - j1;
                if (Q < mainThread.bR)
                    d = e >> 1;
            }
            if (j == 2)
                if (Q > mainThread.bR) {
                    ao = true;
                } else {
                    j = 0;
                    d = 2;
                }
            if (j == 0 || j == 4) {
                if (Math.abs(i1) <= A)
                    fld_m_int = j1;
                else if ((0xff & i1) < 128)
                    fld_m_int -= A;
                else
                    fld_m_int += A;
                fld_m_int = 0xff & fld_m_int;
                l = fld_m_int;
                if (j == 0 && c.B < B)
                    d = c.d;
            } else if (j == 5)
                l = fld_m_int = j1;
        } else {
            j = 0;
        }
        if (j == 5)
            k = 2;
        else if (j == 6)
            k = 5;
        else
            k = 0;
        if (mainThread.bR - i.m > 150L) {
            i.a();
            i.m = mainThread.bR;
        }
    }

    private void i() {
        if (mainThread.bR - h.f > 150L) {
            h.a();
            h.f = mainThread.bR;
        }
        if (O < 0 && !v)
            x = true;
        P = 0xff & P + 1;
        if (N && mainThread.bR > Q) {
            int i1 = 0;
            cls_d d1;
            for (; aw.size() > 0; mainThread.fld_m_Vector.addElement(d1)) {
                d1 = (cls_d) aw.firstElement();
                aw.removeElementAt(0);
                d1.o.a = o.a;
                d1.o.b = o.b;
                if (d1.s == 1)
                    i1++;
                for (int j1 = 0; j1 < d1.q.length; j1++) {
                    d1.q[j1].a = d1.o.a;
                    d1.q[j1].b = d1.o.b;
                }

            }

            mainThread.o(i1);
            x = true;
        }
    }

    private void j() {
        if (c != null) {
            int i1 = MainThread.a(o, c.o);
            i1 = 0xff & i1 + 128;
            int j1;
            if (Math.abs(j1 = fld_m_int - i1) <= A)
                fld_m_int = i1;
            else if ((0xff & j1) < 128)
                fld_m_int -= A;
            else
                fld_m_int += A;
            fld_m_int = 0xff & fld_m_int;
            l = fld_m_int;
        }
        ao = true;
        if (mainThread.bR - i.m > 150L) {
            i.a();
            i.m = mainThread.bR;
        }
        ap += 30;
    }

    private void k() {
        if (b == null && D == 0) {
            int i1 = mainThread.ck.B + 10;
            int k2;
            int k1 = (k2 = o.a - mainThread.ck.o.a) >> 8;
            int i2 = (k2 = o.b - mainThread.ck.o.b) >> 8;
            if ((k1 = k1 * k1 + i2 * i2) < i1 * i1) {
                cls_b b1;
                if (r == 24)
                    b1 = mainThread.t;
                else if (r == 26)
                    b1 = mainThread.s;
                else if (r == 25)
                    b1 = mainThread.r;
                else
                    b1 = mainThread.p;
                int l1 = r - 24;
                b = mainThread.ck;
                O = MainThread.a(b.o, o);
                Q = mainThread.bR + 50L;
                mainThread.cH[l1]++;
                byte byte0 = 9;
                cls_ab ab1 = al;
                al.a(byte0, false);
                cls_aa aa1 = o.a();
                int l2 = 40 * MainThread.g(192);
                int k3 = 40 * MainThread.f(192);
                aa1.a((l2 = b.o.a + l2) >> 8, (l2 = b.o.b + k3) >> 8, 25);
                mainThread.a(2, mainThread.strs[l1 + 249], aa1, b1);
                if (r == 25) {
                    int j1 = 15 + 15 * mainThread.cH[l1];
                    if ((b.H & 0x40) != 0)
                        j1 += 2;
                    int i3;
                    int j2 = ((i3 = 1) << 8) + ((i3 = j1) << 8) / 100;
                    b.e = j2 * (i3 = b.U[0]) >> 8;
                } else if (r == 24)
                    b.H |= 0x10000;
                mainThread.recordManager.a(3, 1, r);
            }
            ao = false;
            return;
        }
        if (N) {
            l = O;
            fld_m_int = O;
            D = 11;
            N = false;
            mainThread.cH[r - 24]--;
            if (r == 25) {
                if ((b.H & 0x40) != 0) {
                    char c1 = '\u014C';
                    int j3;
                    b.e = c1 * (j3 = b.U[0]) >> 8;
                } else {
                    b.e = b.U[0];
                }
            } else if (r == 24 && mainThread.cH[r - 24] == 0)
                b.H &= 0xfffeffff;
            b = null;
        }
        if (b != null) {
            O = 0xff & O + 4;
            Q = mainThread.bR + 50L;
            o.a = b.o.a + (b.B + 10) * MainThread.g(O);
            o.b = b.o.b + (b.B + 10) * MainThread.f(O);
        }
        if (D >= 10) {
            ao = true;
            d = e;
            if (!v)
                x = true;
        }
    }

    private void l() {
        if (Q < mainThread.bR && N && c != null) {
            int i1 = MainThread.a(o, c.o);
            if ((i1 = Math.abs(fld_m_int - i1)) < 32 || i1 > 224) {
                ap += 10;
                if (P++ == 4) {
                    Q = mainThread.bR + 6000L;
                    P = 0;
                    N = false;
                    return;
                }
                int j1;
                cls_d d1;
                (d1 = new cls_d(mainThread, 19, (j1 = o.a) >> 8, (j1 = o.b) >> 8)).l = MainThread.a(o, c.o);
                d1.fld_m_int = d1.l;
                d1.d = d1.e;
                d1.c = c;
                d1.b = this;
                mainThread.fld_m_Vector.addElement(d1);
                mainThread.a(d1);
                Q = mainThread.bR + 2000L;
                N = true;
            }
        }
    }

    private void m() {
        ao = true;
        if (c == null) {
            if (!u && mainThread.j((O + 1) * 9) == 0) {
                u = true;
                n = mainThread.j(256);
            }
            if (a == null)
                if (O > 0) {
                    cls_d d1;
                    (d1 = new cls_d(mainThread, 28, 0, 0)).b = this;
                    mainThread.fld_m_Vector.addElement(d1);
                    a = d1;
                } else {
                    H &= 0xffffdfff;
                }
        } else {
            int i1 = MainThread.a(o, c.o);
            int j1;
            if (N) {
                if (Q > mainThread.bR) {
                    if ((j1 = 0xff & Math.abs(fld_m_int - i1)) < 32 || j1 > 224) {
                        i.j = 2;
                        i.a(0, i.i - 1);
                        d += 2;
                    } else {
                        d = 2;
                        i.j = 1;
                        i.a(0, 0);
                    }
                } else if (t > 40) {
                    d = 2;
                    N = false;
                    Q = mainThread.bR + 3000L;
                }
            } else {
                if (!v && a != null && a.v)
                    v = true;
                if (Q > mainThread.bR) {
                    if (v) {
                        i1 = 0xff & i1 + 128;
                        d += 2;
                        if (a == null)
                            if (O > 0) {
                                cls_d d2;
                                (d2 = new cls_d(mainThread, 28, 0, 0)).b = this;
                                mainThread.fld_m_Vector.addElement(d2);
                                a = d2;
                            } else {
                                H &= 0xffffdfff;
                            }
                    }
                } else {
                    N = true;
                    Q = mainThread.bR + 6000L;
                }
            }
            int id2;
            if (Math.abs(id2 = fld_m_int - i1) <= A)
                fld_m_int = i1;
            else if ((0xff & id2) < 128)
                fld_m_int -= A;
            else
                fld_m_int += A;
            l = fld_m_int;
        }
        i.a(mainThread.bR);
    }

    private void n() {
        int i1 = 0;
        if (c != null && c.s != 18 && c.d > d && c.d > e)
            c = null;
        if ((H & 0x200) != 0 && c != null && (c.s == 15 && (c.H & 0x10) != 0 || c.s == 6 && c.N && c.P == 1))
            c = null;
        if (c != null)
            i1 = MainThread.a(o, c.o);
        if (Q < mainThread.bR && mainThread.j(60) == 0)
            if ((H & 4) != 0) {
                if (mainThread.bY < mainThread.bR && c != null && t <= 100) {
                    cls_d d1 = this;
                    int j2 = 100;
                    int k2 = 2;
                    mainThread.o.removeAllElements();
                    byte byte1;
                    if (r == 36)
                        byte1 = 34;
                    else
                        byte1 = 36;
                    do {
                        if ((d1 = mainThread.b(d1, j2 * j2, byte1)) == null)
                            break;
                        mainThread.o.addElement(d1.o);
                        d1.b(1, 3000);
                        d1.f(k2);
                        d1 = d1;
                        j2 -= 5;
                        k2 <<= 1;
                    } while (j2 > 0);
                    if (mainThread.o.size() > 0) {
                        N = true;
                        Q = mainThread.bR + 10000L;
                        mainThread.o.insertElementAt(o, 0);
                        mainThread.bY = mainThread.bR + 1000L;
                        mainThread.bn[f].j = 0;
                        mainThread.bn[f].a(0, 0);
                        Q = mainThread.bR + 10000L;
                        d = 2;
                        if (v) {
                            byte byte0 = 16;
                            cls_ab ab1 = al;
                            al.a(byte0, false);
                        }
                    }
                    mainThread.bG.b = 0;
                    mainThread.bG.a(0, mainThread.bG.e);
                }
            } else if ((H & 0x100) != 0) {
                N = true;
                Q = mainThread.bR + 10000L;
                e = U[0] << 1;
            } else if ((H & 0x20) != 0 && c != null && c.s == 18 && c.j == 3 && c.F > F && t < 80) {
                N = true;
                Q = mainThread.bR + 10000L;
                C >>= 1;
                j = 0;
                a();
                M[7] = 0L;
                M[6] = 0L;
            }
        switch (j) {
            case 1:
            default:
                break;

            case 0:
                if (c != null) {
                    if (c.s == 18) {
                        if (Q < mainThread.bR) {
                            if (g(256)) {
                                char c1 = '\u014C';
                                int j1;
                                e = c1 * (j1 = U[0]) >> 8;
                                d = Math.min(d, e);
                            }
                            N = false;
                            if ((H & 0x800) != 0 && (c.F > F << 1 || F < G >> 2)) {
                                N = true;
                                Q = mainThread.bR + 10000L;
                                j = 2;
                            }
                            if (!N) {
                                j = 3;
                                z = 4;
                                return;
                            }
                            break;
                        }
                        if (!g(32)) {
                            j = 3;
                            z = 4;
                            return;
                        }
                        break;
                    }
                    if (c.B == B)
                        break;
                    if (c.B > B)
                        i1 = 0xff & i1 + 128;
                    int k1 = fld_m_int - i1;
                    if ((0xff & k1) < 64 || (0xff & k1) > 192)
                        ao = true;
                    else
                        ao = false;
                    if (Math.abs(k1) <= A)
                        fld_m_int = i1;
                    else if ((0xff & k1) < 128)
                        fld_m_int -= A;
                    else
                        fld_m_int += A;
                    l = 0xff & fld_m_int;
                    return;
                }
                if (!u && mainThread.j(100) == 0) {
                    u = true;
                    n = mainThread.j(256);
                }
                ao = true;
                return;

            case 2:
                if (Q < mainThread.bR)
                    j = 0;
                // fall through

            case 3:
                if (c != null && (c.s == 18 || c.s == 17)) {
                    if (j == 2) {
                        i1 = 0xff & i1 + 128;
                        if (g(256)) {
                            N = false;
                            char c2 = '\u014C';
                            int l1;
                            e = c2 * (l1 = U[0]) >> 8;
                            d = Math.min(d, e);
                        }
                    } else {
                        if (mainThread.j(3) == 0 && ++z > 20) {
                            j = 0;
                            c = null;
                        }
                        if (!g(32))
                            if ((H & 1) != 0 && M[6] < mainThread.bR && c != null && c.M[5] < mainThread.bR && mainThread.j(80) == 0)
                                M[6] = mainThread.bR + 1500L;
                            else if ((H & 2) != 0 && M[7] < mainThread.bR && mainThread.j(60) == 0)
                                M[7] = mainThread.bR + 1500L;
                    }
                    if (j == 2 && g(2048)) {
                        ao = false;
                        return;
                    }
                    if (g(32))
                        break;
                    int i2 = fld_m_int - i1;
                    if (((0xff & i2) < 64 || (0xff & i2) > 192) && ((H & 0x200) == 0 || j != 3 || !c.g(32)))
                        ao = true;
                    else
                        ao = false;
                    if (Math.abs(i2) <= A)
                        fld_m_int = i1;
                    else if ((0xff & i2) < 128)
                        fld_m_int -= A;
                    else
                        fld_m_int += A;
                    l = 0xff & fld_m_int;
                    return;
                }
                j = 0;
                break;
        }
    }

    private void o() {
        if (c == null) {
            if (!u && mainThread.j(100) == 0) {
                u = true;
                n = mainThread.j(256);
            }
            ao = true;
            return;
        }
        int i1 = MainThread.a(o, c.o);
        int j1;
        if (c.ap >= ap || c.B >= B) {
            i1 = 0xff & i1 + 128;
            ao = true;
        } else if ((j1 = 0xff & fld_m_int - i1) < 64 || j1 > 192)
            ao = true;
        else
            ao = false;
        if (Math.abs(j1 = fld_m_int - i1) <= A)
            fld_m_int = i1;
        else if ((0xff & j1) < 128)
            fld_m_int -= A;
        else
            fld_m_int += A;
        l = fld_m_int;
    }

    private void p() {
        ao = true;
        fld_m_int += A;
        fld_m_int = 0xff & fld_m_int;
    }

    private void q() {
        label0:
        {
            if (j == 2)
                return;
            if (Q < mainThread.bR && N && v && c != null) {
                int i1 = MainThread.a(o, c.o);
                if ((i1 = Math.abs(fld_m_int - i1)) < 32 || i1 > 224) {
                    if (P++ > 0) {
                        j = 2;
                        N = false;
                        break label0;
                    }
                    int j1;
                    cls_d d1;
                    (d1 = new cls_d(mainThread, 19, (j1 = o.a) >> 8, (j1 = o.b) >> 8)).l = MainThread.a(o, c.o);
                    d1.fld_m_int = d1.l;
                    d1.d = d1.e;
                    d1.c = c;
                    d1.b = this;
                    mainThread.fld_m_Vector.addElement(d1);
                    Q = mainThread.bR + 2000L;
                    N = true;
                }
                return;
            }
            if (!N && Q < mainThread.bR) {
                N = true;
                Q = mainThread.bR + 2000L;
            }
        }
    }

    private void r() {
        if (N) {
            h.a();
            return;
        }
        T.a(mainThread.bR);
        if (T.b == 0)
            N = true;
    }

    final void a(cls_d d1, int i1) {
        if (mainThread.R == 1) {
            switch (s) {
                default:
                    break;

                case 21: // '\025'
                case 22: // '\026'
                    switch (d1.s) {
                        case 0:
                            c = d1;
                            int j1 = MainThread.a(o, c.o);
                            if (s == 22 && j == 2)
                                j1 = 0xff & j1 + 128;
                            int j2 = fld_m_int - j1;
                            ao = true;
                            if (Math.abs(j2) <= A)
                                fld_m_int = j1;
                            else if ((0xff & j2) < 128)
                                fld_m_int -= A;
                            else
                                fld_m_int += A;
                            fld_m_int = 0xff & fld_m_int;
                            break;
                    }
                    return;

                case 1:
                    if (c == null && i1 < 100) {
                        c = d1;
                        t = i1;
                    }
                    break;
            }
            return;
        }
        if (s == 0 || s == 7 || s == 16 || d1.s == 12 || M[3] > mainThread.bR || M[0] > mainThread.bR || M[1] > mainThread.bR || M[5] > mainThread.bR)
            return;
        if (d1.s == 17)
            i1 -= 55 - E;
        if (c != null) {
            boolean flag;
            if (s == 9 || s == 1 && c != null && (c.g(2048) || c.s == 17) || s == 11 && j != 0 || s == d1.s)
                flag = false;
            else
                flag = true;
            if (c.x || c.j == 1)
                c = null;
            else if (flag && d1 != c && (d1.B > B || d1.ap > ap) && i1 < t && d1.s != s && d1.s != 7)
                c = d1;
        }
        if (d1 == c)
            t = i1;
        switch (s) {
            case 1:
                switch (d1.s) {
                    case 1:
                        if (c == null && i1 < 100) {
                            c = d1;
                            t = i1;
                            return;
                        }
                        break;

                    case 17: // '\021'
                        if (c == null && i1 < 200) {
                            c = d1;
                            t = i1;
                            return;
                        }
                        break;

                    default:
                        if (d1.g(2048)) {
                            c = d1;
                            t = i1;
                            return;
                        }
                        if (c == null || !c.g(2048)) {
                            if (i1 < 60 && c != null && c.s == 1)
                                c = null;
                            if (c == null && i1 < 60 || c != null && i1 < t) {
                                c = d1;
                                t = i1;
                                return;
                            }
                        }
                        break;
                }
                break;

            case 4:
                if (c != null || d1.s == s)
                    return;
                if (d1.ap > ap && i1 < 90 || B > d1.B && i1 < 100) {
                    int k1 = MainThread.a(o, d1.o);
                    int k2;
                    if ((k2 = 0xff & fld_m_int - k1) < 112 || k2 > 144) {
                        c = d1;
                        t = i1;
                    }
                    return;
                }
                break;

            case 3:
                if (i1 < 60 && d1.B > B) {
                    c = d1;
                    t = i1;
                    int l1 = MainThread.a(o, c.o);
                    l1 = 0xff & l1 + 128;
                    int l2 = fld_m_int - l1;
                    ao = true;
                    d = e;
                    if (Math.abs(l2) <= A)
                        l = l1;
                    else if ((0xff & l2) < 128)
                        l -= A;
                    else
                        l += A;
                    l = 0xff & l;
                    return;
                }
                break;

            case 11: // '\013'
                if (c != null) {
                    if (j == 0 && c.s == 0 && c.B < B && c.ap < ap && v)
                        j = 4;
                    return;
                }
                switch (d1.s) {
                    case 1:
                    case 7:
                    case 11: // '\013'
                        return;
                }
                if (i1 < 100) {
                    c = d1;
                    t = i1;
                    if (c.s == 0 && c.B < B && c.ap < ap) {
                        if (v) {
                            j = 4;
                            return;
                        }
                    } else {
                        j = 0;
                        return;
                    }
                }
                break;

            case 8:
                if (c == null) {
                    if (i1 < 80 && d1.B > B || d1.ap > ap && d1.s != 17) {
                        c = d1;
                        t = i1;
                    }
                } else if (d1 == c && (i1 > 120 || d1.B < B))
                    c = null;
                if (c == null) {
                    ao = true;
                    return;
                }
                if (d1 == c) {
                    int i2 = MainThread.a(o, c.o);
                    if (i1 < 45 || !N && mainThread.bR < Q && i1 < 60) {
                        i2 = 0xff & i2 + 128;
                        ao = true;
                        d = e;
                    } else if (!N && mainThread.bR > Q) {
                        Q = 0L;
                        N = true;
                        P = 0;
                    }
                    int i3;
                    if (Math.abs(i3 = fld_m_int - i2) < A)
                        fld_m_int = i2;
                    else if ((0xff & i3) < 128)
                        fld_m_int -= A;
                    else
                        fld_m_int += A;
                    fld_m_int = 0xff & fld_m_int;
                    l = fld_m_int;
                    return;
                }
                break;

            case 17: // '\021'
                if (d1 == c && i1 > 118)
                    c = null;
                else if (c == null && i1 < 100 && d1.s != 0 && d1.B > B) {
                    c = d1;
                    t = i1;
                }
                if (i1 + E < 55 && (d1.H & 0x2000) == 0 && d1.s != 1 && d1.s != 17 && d1.M[1] < mainThread.bR) {
                    d1.b(1, 1000);
                    d1.b(5, 1000);
                    if (d1.s == 0) {
                        mainThread.bT = 0L;
                        mainThread.H = false;
                        d1.c = null;
                        return;
                    }
                }
                break;

            case 9:
                if (d1 == b && i1 > 130) {
                    c = null;
                    return;
                }
                break;

            case 13:
                if (c == null && d1.s == 0 && (a != null && d1.B > a.B || a == null) && i1 < 80 && d1.B < B) {
                    c = d1;
                    t = i1;
                    return;
                }
                break;

            case 15:
                if ((H & 0x10) != 0 && d1.s != 15 && i1 < P)
                    d1.f(z);
                // fall through

            case 2:
            case 5:
            case 6:
            case 7:
            case 10:
            case 12: // '\f'
            case 14: // '\016'
            case 16:
            default:
                if (s == 18) {
                    if (d1.s == 17) {
                        if (i1 < 110) {
                            c = d1;
                            t = i1;
                            j = 2;
                            Q = mainThread.bR + 2000L;
                            return;
                        }
                        if (d1 == c)
                            c = null;
                    }
                    if (i1 < 30 && d1.s == 1 && j == 2 && F < G || F == G && d1.s == 18) {
                        c = d1;
                        t = i1;
                        return;
                    }
                    if (i1 < 100 && (c == null && d1.s == 18 || c != null && c.s == 1 && d1.s == 18 && (d1.F <= F || F == G) || c != null && c.s == 18 && d1.s == 1 && c.F > F << 1)) {
                        c = d1;
                        t = i1;
                        return;
                    }
                }
                if (d1.s == s || d1.s == 7)
                    return;
                if (c == null) {
                    if (d1.B != B && i1 < 100 || d1.B == B && i1 < 50) {
                        c = d1;
                        t = i1;
                        return;
                    }
                    break;
                }
                if (c.B < B && i1 < 80 && d1.B > B) {
                    c = d1;
                    t = i1;
                    return;
                }
                if (d1 == c && i1 > 130)
                    c = null;
                break;
        }
    }

    final void a(cls_d d1) {
        label0:
        {
            if (mainThread.R == 1) {
                label1:
                switch (s) {
                    default:
                        break;

                    case 0:
                        switch (d1.s) {
                            default:
                                break label0;

                            case 23: // '\027'
                            case 24: // '\030'
                                if (d1.s == 23) {
                                    d1.x = true;
                                    mainThread.bS = mainThread.bR + 2000L;
                                    al.a(1);
                                    if (++mainThread.ai == 6 * ((mainThread.T >> 1) + 1))
                                        mainThread.B = true;
                                    else
                                        mainThread.K.a();
                                    if (F < G)
                                        F++;
                                    mainThread.recordManager.a(1, 1, d1.r);
                                } else {
                                    if (mainThread.cr == -1 && d1.s == 24) {
                                        mainThread.cr = d1.r - 43;
                                        d1.x = true;
                                        mainThread.recordManager.a(4, 1, mainThread.cr);
                                        al.a(9);
                                    }
                                    break label0;
                                }
                                break;
                        }
                        break;

                    case 9:
                        if (d1 == b)
                            break;
                        switch (d1.s) {
                            default:
                                break;

                            case 0:
                                d1.f(z);
                                if (mainThread.bV > mainThread.bR) {
                                    int i1 = MainThread.c(d1.o.a - o.a);
                                    int k1 = MainThread.c(d1.o.b - o.b);
                                    int i2 = i1 * i1 + k1 * k1;
                                    int i3 = d1.d;
                                    d1.C <<= 4;
                                    d1.p.a = MainThread.a(2560, MainThread.g(d1.l));
                                    d1.p.b = MainThread.a(2560, MainThread.f(d1.l));
                                    B = 1;
                                    MainThread.a(this, d1, i2, i1, k1);
                                    d1.C >>= 4;
                                    d1.d = i3;
                                } else {
                                    x = true;
                                }
                                break label1;

                            case 19: // '\023'
                            case 20: // '\024'
                            case 21: // '\025'
                            case 22: // '\026'
                                d1.j = 1;
                                x = true;
                                break;
                        }
                        break label0;

                    case 19: // '\023'
                    case 20: // '\024'
                    case 21: // '\025'
                    case 22: // '\026'
                        if (d1.s != 0)
                            break;
                        if (mainThread.bV < mainThread.bR) {
                            if (j != 1)
                                d1.f(z);
                            break label0;
                        }
                        j = 1;
                        break;
                }
                return;
            }
            switch (s) {
                case 8:
                case 10:
                case 11: // '\013'
                case 14: // '\016'
                case 17: // '\021'
                default:
                    break;

                case 7:
                    if (v && !N && ((d1.H & 2) != 0 || (d1.H & 0x10) != 0 || d1.M[6] > mainThread.bR)) {
                        N = true;
                        Q = mainThread.bR + 500L;
                        return;
                    }
                    break;

                case 5:
                    if (d1.s != 5 && (d1.H & 0x2000) == 0) {
                        d1.b(0, 10000);
                        return;
                    }
                    break;

                case 6:
                    if (d1.s == 6 || (d1.H & 0x2000) != 0 || M[5] >= mainThread.bR || M[0] >= mainThread.bR || M[1] >= mainThread.bR || !N)
                        break;
                    if (P == 1) {
                        d1.b(2, 4000);
                        return;
                    }
                    if (P == 0) {
                        d1.M[4] = mainThread.bR + 3000L;
                        return;
                    }
                    break;

                case 15:
                    if ((H & 0x10) != 0 && d1.s != 15) {
                        d1.f(mainThread.cC[r][2]);
                        return;
                    }
                    break;

                case 9:
                    if (d1.s != 8) {
                        d1.f(z);
                        x = true;
                        return;
                    }
                    break;

                case 12: // '\f'
                    if (r != 26 || b == null || d1 == b || d1.M[2] >= mainThread.bR || (d1.H & 0x2000) != 0 && d1.s != 13)
                        break;
                    d1.b(2, 4000);
                    if (d1.s == 13 && d1.O > 0 && d1.a != null)
                        d1.a.b(2, 4000);
                    cls_u u1;
                    (u1 = new cls_u(mainThread.bd)).n = o.a();
                    u1.l = 150;
                    u1.m = mainThread.bR;
                    mainThread.K.vector.addElement(u1);
                    return;

                case 13:
                    if (N && d1.s == 0) {
                        N = false;
                        Q = mainThread.bR + 3000L;
                        int j1 = MainThread.c(d1.o.a - o.a);
                        int l1 = MainThread.c(d1.o.b - o.b);
                        int j2 = j1 * j1 + l1 * l1;
                        C <<= 4;
                        p.a = MainThread.a(2560, MainThread.g(l));
                        p.b = MainThread.a(2560, MainThread.f(l));
                        MainThread.a(this, d1, j2, j1, l1);
                        C >>= 4;
                        d1.fld_m_int = d1.l;
                        fld_m_int = l;
                        d1.f(z);
                        d = e << 1;
                        return;
                    }
                    break;

                case 16:
                    if (d1.s == 11 || d1.s == 9 || (d1.s == 0 || d1.s == 18) && d1.g(32)) {
                        if (d1.s == 11) {
                            if (d1.j != 2) {
                                fld_m_int = l = MainThread.a(d1.o, o);
                                return;
                            }
                            d1.f(z);
                            d1.j = 0;
                            d1.b(5, 2500);
                        }
                        x = true;
                        byte byte0;
                        byte byte2;
                        if (r == 32) {
                            byte0 = 2;
                            byte2 = 33;
                        } else {
                            if (r != 33)
                                break;
                            byte0 = 3;
                            byte2 = 34;
                        }
                        int k2 = 256 / byte0;
                        for (int j3 = 0; j3 < byte0; j3++) {
                            (d1 = new cls_d(mainThread, byte2, MainThread.c(o.a), MainThread.c(o.b))).H &= 0xffffefff;
                            d1.l = d1.fld_m_int = 0xff & l - k2 * j3;
                            d1.d = d << 2;
                            mainThread.fld_m_Vector.addElement(d1);
                        }

                        return;
                    }
                    if (d1.s == 16) {
                        fld_m_int = l = MainThread.a(d1.o, o);
                        return;
                    }
                    if (d1.s == 12 || mainThread.B)
                        break;
                    d1.M[3] = mainThread.bR + (long) inf_m.ac[O];
                    if (d1.s == 0) {
                        al.a(17);
                        if (!mainThread.recordManager.t)
                            mainThread.bZ = mainThread.bR + 2000L;
                    }
                    x = true;
                    return;

                case 18: // '\022'
                    if ((H & 0x10) != 0 && M[9] < mainThread.bR && d1.B >= B)
                        M[9] = mainThread.bR + 3000L;
                    switch (d1.s) {
                        case 18: // '\022'
                            boolean flag = false;
                            if (j == 3 && c == d1) {
                                d1.c = this;
                                if (!g(32)) {
                                    j = 2;
                                    Q = mainThread.bR + 1000L + (long) mainThread.j(1000);
                                } else {
                                    j = 0;
                                }
                                if ((d1.H & 1) != 0 && d1.M[6] > mainThread.bR) {
                                    if ((H & 1) != 0 && M[6] > mainThread.bR)
                                        d1.b(5, 1250);
                                } else if ((d1.H & 0x80) != 0 && !d1.s() && mainThread.j(8) == 0) {
                                    cls_aa aa1 = d1.o.a();
                                    int l2 = 50 * MainThread.g(192);
                                    int k3 = 50 * MainThread.f(192);
                                    aa1.a(MainThread.c(d1.o.a + l2), MainThread.c(d1.o.b + k3), 25);
                                    mainThread.a(2, mainThread.strs[46], aa1, mainThread.p);
                                    d1.R = mainThread.bR + 1000L;
                                    flag = true;
                                } else {
                                    if ((H & 1) != 0 && M[6] > mainThread.bR)
                                        d1.b(5, 2500);
                                    if ((H & 2) != 0 && M[7] > mainThread.bR)
                                        z = Math.max(z, 14);
                                    if (g(256)) {
                                        z += z >> 2;
                                        d1.b(5, 1250);
                                    }
                                    z += z >> 1;
                                    d1.f(z);
                                    if (mainThread.recordManager.b)
                                        mainThread.disp.vibrate(150);
                                }
                                if (!flag)
                                    al.a(6);
                            }
                            break;
                    }
                    if ((H & 0x10) == 0 || M[9] <= mainThread.bR)
                        break;
                    byte byte1 = 4;
                    if (g(32))
                        byte1 = 8;
                    d1.f(byte1);
                    break;
            }
        }
    }

    final void f(int i1) {
        if (mainThread.B && s == 0 && mainThread.R != 2 || R > mainThread.bR)
            return;
        int j1 = i1;
        if (mainThread.R == 0)
            R = mainThread.bR + 1000L;
        else
            R = mainThread.bR + 500L;
        if (mainThread.R == 1) {
            if (s == 0) {
                if (mainThread.bV < mainThread.bR && (H & 0x10000) == 0) {
                    F -= i1;
                    w = true;
                }
                H &= 0xfffeffff;
            }
        } else {
            if (s == 13 && O > 0)
                if (a != null) {
                    a.f(i1);
                    return;
                } else {
                    cls_d d1;
                    (d1 = new cls_d(mainThread, 28, 0, 0)).b = this;
                    mainThread.fld_m_Vector.addElement(d1);
                    a = d1;
                    return;
                }
            if (s != 1 && s != 7) {
                if ((H & 0x2000) != 0 || g(32))
                    return;
                if ((H & 8) != 0)
                    if (s == 0 || (H & 0x20) != 0)
                        j1 = Math.max(1, i1 - (i1 >> 2));
                    else
                        j1 = Math.max(1, i1 - (i1 >> 3));
                if (s == 0 && mainThread.cH[0] != 0)
                    w = false;
                else
                    w = true;
                if (s == 0) {
                    if (w) {
                        mainThread.aj >>= 1;
                        mainThread.aj -= j1;
                        if (mainThread.aj <= 0) {
                            byte byte0 = 10;
                            cls_ab ab1 = al;
                            al.a(byte0, false);
                            B -= 7;
                            mainThread.aj = B >> 1;
                            M[11] = 1500L + mainThread.bR;
                            I = -1;
                            a();
                        }
                        if (mainThread.R == 0)
                            mainThread.recordManager.a(1, j1, j1);
                        int k1 = mainThread.fld_m_Vector.size();
                        for (int j2 = 0; j2 < k1; j2++) {
                            cls_d d2;
                            if ((d2 = (cls_d) mainThread.fld_m_Vector.elementAt(j2)).s == 12 && d2.b != null)
                                d2.N = true;
                        }

                    } else {
                        int l1 = mainThread.fld_m_Vector.size();
                        for (int k2 = 0; k2 < l1; k2++) {
                            cls_d d3;
                            if ((d3 = (cls_d) mainThread.fld_m_Vector.elementAt(k2)).r == 24 && d3.b != null) {
                                d3.N = true;
                                byte byte1 = 10;
//                                k2 = al;
                                al.a(byte1, false);
                                return;
                            }
                        }

                    }
                } else {
                    F -= j1;
                    if (F <= 0) {
                        x = true;
                        int i2 = Math.max(1, B / 7);
                        i2 = Math.min(20, i2);
                        a(i2, -1);
                        if (v && mainThread.R != 4) {
                            byte byte2 = 21;
                            cls_ab ab2 = al;
                            al.a(byte2, false);
                        }
                    }
                }
            } else if (s == 7 && !N) {
                N = true;
                Q = mainThread.bR + (long) (mainThread.B ? '\0' : 500);
            }
        }
        if (w) {
            k = 1;
            M[8] = mainThread.bR + 3000L;
            if (mainThread.R == 0 && s == 0 || mainThread.R == 2 && s == 18) {
                cls_aa aa1 = o.a();
                int l2 = 50 * MainThread.g(192);
                int i3 = 50 * MainThread.f(192);
                aa1.a((l2 = o.a + l2) >> 8, (l2 = o.b + i3) >> 8, 25);
                cls_b bi1;
                if (M[2] > mainThread.bR && ar == mainThread.bR + 1000L && i1 == 2)
                    bi1 = mainThread.s;
                else
                    bi1 = mainThread.r;
                mainThread.a(1, Integer.toString(-j1), aa1, bi1);
            }
        }
    }

    final void a(int i1, int j1) {
        mainThread.o(i1);
        i1 = 256 / i1;
        for (int k1 = 0; k1 < 256; k1 += i1) {
            int l1;
            cls_d d1 = new cls_d(mainThread, 1, (l1 = o.a) >> 8, (l1 = o.b) >> 8);
            if (j1 != -1)
                d1.f = j1;
            d1.d = d1.e << 3;
            d1.fld_m_int = d1.l = k1;
            d1.H &= 0xffffefff;
            mainThread.fld_m_Vector.addElement(d1);
        }

    }

    final void b(int i1, int j1) {
        if (g(32))
            return;
        if (S > mainThread.bR && M[i1] > mainThread.bR)
            return;
        if (mainThread.R == 0)
            S = mainThread.bR + 500L;
        if ((H & 8) != 0)
            j1 >>= 1;
        if (s == 0) {
            if (i1 == 0) {
                if (M[i1] > mainThread.bR)
                    al.b(18);
                al.a(18, true);
            } else if (i1 == 2) {
                if (M[i1] > mainThread.bR)
                    al.b(15);
                al.a(15, true);
            }
        } else if (s == 18 && (i1 == 5 || i1 == 1) && g(256)) {
            N = false;
            char c1 = '\u014C';
            int k1;
            e = c1 * (k1 = U[0]) >> 8;
            d = Math.min(d, e);
        }
        if (s == 15)
            H = H &= 0xffffffef;
        M[i1] = mainThread.bR + (long) j1;
    }

    private boolean s() {
        return M[0] > mainThread.bR || M[2] > mainThread.bR || M[3] > mainThread.bR || M[1] > mainThread.bR || M[5] > mainThread.bR;
    }

    final boolean g(int i1) {
        return (H & i1) != 0 && N;
    }

    final void b(cls_d d1) {
        f = d1.f;
        K = d1.K;
        g = d1.g;
        H = d1.H;
        L = d1.L;
        J = d1.J;
        E = d1.E;
        aq = d1.aq;
    }


    final void d() {
        Vector[] avector = new Vector[inf_m.W.length];         // astore_1
        cls_l l3 = new cls_l(-1, 0, 0);                              // astore_3
        int i1 = 0;
        for (; i1 < inf_m.W.length; i1++) {
            avector[i1] = new Vector();
            for (int i2 = 0; i2 < J.size(); i2++) {
                cls_l l1;
                if ((l1 = (cls_l) J.elementAt(i2)).d == inf_m.W[i1])
                    avector[i1].addElement(l1);
            }
        }
        J.removeAllElements();

        for (i1 = 0; i1 < inf_m.W.length; i1++) {
            Vector vc = avector[i1];
            int iv = inf_m.W[i1];
            if (iv != 16384 && vc.size() >= 2) {
                vc.insertElementAt(l3, vc.size());
                int j1 = 0;
                for (; j1 < vc.size(); j1++) {
                    cls_l ls = (cls_l) vc.elementAt(0);  // astore_2
                    int k1 = ls.b;
                    if (k1 > 128) {
                        k1 = 256 - k1;
                    }
                    vc.removeElementAt(0);
                    if (!ls.equals(l3)) {
                        j1 = 0;
                        Object obj  ;
                        do {
                            obj = vc.elementAt(j1++);
                        } while (!l3.equals(obj));
                        if (j1 >= vc.size()) {
                            vc.indexOf(ls, vc.size());
                            continue;
                        }
                        if (j1 + 1 == vc.size()) {
                            cls_l l8 = (cls_l) vc.elementAt(j1);
                            int i9 = l8.b;
//                            int j3;
                            if ((i9) > 128)
                                i9 = 256 - i9;
                            if (k1 >= i9)
                                vc.insertElementAt(ls, j1);
                            else
                                vc.insertElementAt(ls, j1 + 1);
                        }
                        int k3;
                        if ((k3 = ((cls_l) vc.elementAt(j1)).b) > 128)
                            k3 = 256 - k3;
                        if (k1 >= k3) {
                            vc.insertElementAt(ls, j1);
                        } else {
                            if (j1 + 1 == vc.size()) {
                                vc.insertElementAt(ls, j1 + 1);
                            }
                        }
                    } else {
                        break;
                    }
                }
            }
        }

        // L413

        for (i1 = 0; i1 < inf_m.W.length; i1++) {
            for (int j2 = 0; j2 < avector[i1].size(); j2++)
                J.addElement(avector[i1].elementAt(j2));
        }

    }


//    final void d_sf()
//    {
//        Vector avector[];
//        l l3;
//        int j1;
//        avector = new Vector[fld_m_int.W.length];
//        l3 = new l(-1, 0, 0);
//        for(int i1 = 0; i1 < fld_m_int.W.length; i1++)
//        {
//            avector[i1] = new Vector();
//            for(int i2 = 0; i2 < J.size(); i2++)
//            {
//                l l1;
//                if((l1 = (l)J.elementAt(i2)).d == fld_m_int.W[i1])
//                    avector[i1].addElement(l1);
//            }
//
//        }
//
//        J.removeAllElements();
//        for(j1 = 0;j1 < fld_m_int.W.length;j1++){
////_L7:
////        if(j1 >= fld_m_int.W.length) goto _L2; else goto _L1
////_L1:
//        Vector vector;
//        vector = avector[j1];
//        if(fld_m_int.W[j1] == 16384 || vector.size() < 2)
//            continue; /* Loop/switch isn't completed */
//        vector.insertElementAt(l3, vector.size());
//        boolean flag = false;
////_L4:
//        l l2;
//        int k2;
//        int i3= (l2 = (l)vector.elementAt(0)).b;
//        if((i3 ) > 128)
//            i3 = 256 - i3;
//        vector.removeElementAt(0);
//        if(l2.equals(l3))
//            continue; /* Loop/switch isn't completed */
//        for(k2 = 0; !vector.elementAt(k2++).equals(l3););
//        if(k2 >= vector.size())
//        {
//            vector.insertElementAt(l2, vector.size());
//            continue; /* Loop/switch isn't completed */
//        }
//        if(k2 + 1 == vector.size())
//        {
//            int j3;
//            if((j3 = ((l)vector.elementAt(k2)).b) > 128)
//                j3 = 256 - j3;
//            if(i3 >= j3)
//                vector.insertElementAt(l2, k2);
//            else
//                vector.insertElementAt(l2, k2 + 1);
//            continue; /* Loop/switch isn't completed */
//        }
////_L5:
//        int k3;
//        if((k3 = ((l)vector.elementAt(k2)).b) > 128)
//            k3 = 256 - k3;
//        if(i3 >= k3)
//        {
//            vector.insertElementAt(l2, k2);
//        } else {
//            if (k2 + 1 == vector.size()) {
////                    break label0;
//                vector.insertElementAt(l2, k2 + 1);
//            }
//        }
//        if(true) goto _L4; else goto _L3
//_L3:
//        k2++;
//          goto _L5
//        if(true) goto _L4; else goto _L6
//        }
////_L6:
////        j1++;
////          goto _L7
////_L2:
//        for(int k1 = 0; k1 < fld_m_int.W.length; k1++)
//        {
//            for(int j2 = 0; j2 < avector[k1].size(); j2++)
//                J.addElement(avector[k1].elementAt(j2));
//
//        }
//
//        return;
//    }

}